์คํ๋ง ์ ๋ฌธ - ์ฝ๋๋ก ๋ฐฐ์ฐ๋ ์คํ๋ง ๋ถํธ, ์น MVC, DB ์ ๊ทผ ๊ธฐ์ ์ ๋ค์ผ๋ฉฐ ์ ๋ฆฌํ๋ POST์ ๋๋ค.
์ ์ฒด์ ์ธ ํ๋ฆ
- Spring Project ์์ฑ
- Spring boot๋ก ์น ์๋ฒ ์คํ
- ํ์ ๋๋ฉ์ธ ๊ฐ๋ฐ
- ์น MVC ๊ฐ๋ฐ
- DB ์ฐ๋ - JDBC, JPA, Spring data JPA
- ํ ์คํธ ์ผ์ด์ค ์์ฑ
๐ ๋น์ฆ๋์ค ์๊ตฌ์ฌํญ ์ ๋ฆฌ
- Data: ํ์ID, ์ด๋ฆ, ๋น๋ฐ๋ฒํธ, ์ ํ๋ฒํธ
- ๊ธฐ๋ฅ: ํ์ ๋ฑ๋ก, ์กฐํ
โ ์ผ๋ฐ์ ์ธ ์น ์ดํ๋ฆฌ์ผ์ด์ ๊ณ์ธต ๊ตฌ์กฐ
- ์ปจํธ๋กค๋ฌ: ์น MVC์ ์ปจํธ๋กค๋ฌ
- ์๋น์ค: ํต์ฌ ๋น์ฆ๋์ค logic ๊ตฌํ (ex. ํ์์ ์ค๋ณต ๊ฐ์ ์ด ๋ถ๊ฐ, ...)
- ๋ฆฌํฌ์งํ ๋ฆฌ: DB์ ์ ๊ทผ, ๋๋ฉ์ธ ๊ฐ์ฒด๋ฅผ DB์ ์ ์ฅํ๊ณ ๊ด๋ฆฌ
- ๋๋ฉ์ธ: ๋น์ฆ๋์ค ๋๋ฉ์ธ ๊ฐ์ฒด (ex. ํ์, ์ฃผ๋ฌธ ๋ฑ ์ฃผ๋ก DB์ ์ ์ฅ๋๊ณ ๊ด๋ฆฌ๋จ)
ํด๋์ค ์์กด ๊ด๊ณ
.png)
- ์์ง DB storage๊ฐ ์ ์ ๋์ง ์์๋ค๋ ๊ฐ์ ์ด๊ธฐ์,
interface๋ก ๊ตฌํ ํด๋์ค๋ฅผ ๋ณ๊ฒฝํ ์ ์๋๋ก ์ค๊ณ - Memory ๊ธฐ๋ฐ์ ๋ฐ์ดํฐ ์ ์ฅ์๋ฅผ ์ฌ์ฉํ์ฌ ๋งค์ฐ ๋จ์ํ ๊ตฌํ (๋์คํฌ๊ฐ ์๋ Main memory์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์)
๐ ํ์ domain๊ณผ repository ๋ง๋ค๊ธฐ
โ ํ์ domain ์์ฑ
src/main/java/hello.hellospring/domain ๋ผ๋ ์๋ก์ด Package ์์,
Member ๋ผ๋ ์๋ก์ด Class๋ฅผ ์์ฑํ๋ค.
Member class์ ์๊ตฌ์ฌํญ์์ ๋ช
์ํ๋ ํ์๊ณผ ๊ด๋ จ๋ Data๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด
์๋์ ๊ฐ์ด ๋ณ์๋ค์ ์ ์ธํ๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ ๋ณ์์ ๋ํ Getter & Setter ๋ ์์ฑํ๋ค.
Getter & Setter์ ํ์์ฑ: https://ecsimsw.tistory.com/387
public class Member {
private Long id;
private String name;
private int pwd;
private String phone;
}
๊ทธ๋ฆฌ๊ณ , src/main/java/hello.hellospring/repository ๋ผ๋ Package๋ก ํ์ ๊ฐ์ฒด (= Member Class)๋ฅผ ์ ์ฅํ๊ณ ์ด ์์ MemberRepository ๋ผ๋ Interface ๋ฅผ ์์ฑํ์ฌ ํ์๊ณผ ๊ด๋ จ๋ ๊ธฐ๋ฅ๋ค์ ์ ์ธํ๋ค.
package hello.hellospring.repository;
import hello.hellospring.domain.Member;
import java.util.List;
import java.util.Optional;
public interface MemberRepository {
Member save(Member member);
Optional<Member> findById(Long id);
Optional<Member> findByName(String name);
Optional<Member> findByPhone(String phone);
Optional<Member> findByPwd(int pwd);
List<Member> findAll();
Member drop();
}
Optional<>์ ๋ค์ ๋ช ์๋ API๊ฐ ๊ฐ์ ธ์จ ๊ฐ์ฒด๊ฐ null์ผ ์๋, ์๋ ์๋ ์๋๋ฐ null์ธ ๊ฒฝ์ฐ๋ฅผ ๋๋นํด ์ด๋ฅผ ๊ฐ์ธ์ฃผ๋ Wrapper ์ญํ ์ ์ํํ๋ค. (JAVA 8์ ๋ด์ฅ๋ ๊ธฐ๋ฅ)
- ๊ทธ๋์
get()method ์ฌ์ฉ ์,isPresent()๋ฅผ ์ฌ์ฉํ์ฌ null ์ฌ๋ถ๋ฅผ ํ๋จํ๋ค.
save๋ก ์ ์ฅ์์ ํ์ ์ ๋ณด๊ฐ ์ ์ฅ- ์ดํ ์๋ 4๊ฐ์ ๊ธฐ๋ฅ๋ค๋ก ์ ์ฅ๋ ํ์์ ๋ณด๋ฅผ ์กฐํํ๊ณ ,
findAll์ ๋ชจ๋ ํ์์ ๋ณด๋ฅผ ๊ฐ์ ธ์ค๋ ๊ธฐ๋ฅ drop์ ํ์ ์ ๋ณด ์ญ์ ์ฉ์ผ๋ก ๋ง๋ค์๋๋ฐ, ๋ฐ๋ผํ๋ฉด์ ๋ง๋ค์ด๋ณด๋ ค๋ ๊ธฐ๋ฅ
์ด์ ๊ตฌํ์ฒด๋ฅผ ๋ง๋ค๊ธฐ ์ํด, repository ์์ MemoryMemberRepository ๋ผ๋ Class๋ฅผ ์์ฑํ๋ค.
public class MemoryMemberRepository implements MemberRepository ํ ํ, option + enter(return) ํ์ฌ implements method -> Ok ํ๋ค.
๊ทธ๋ผ ์์ฑํ interface์ method๋ค์ Override ํ ์ ์๋ค.
import java.util.Map;
private static Map<Long, Member> store = new HashMap<>();
private static long sequence = 0L;
id๋ฅผ Key๋ก์ ์ฌ์ฉํ๊ธฐ ์ํดLong์ผ๋ก ์ง์ ํด์ฃผ๊ณ , '0,1,2'์ ๊ฐ์ด Key ๊ฐ์ ์์ฑํด์ฃผ๋sequence๋ฅผ ์ ์ธํ๋ค.
Map collection class๋ Key์ value๋ฅผ ํ๋์ ์์ผ๋ก ์ ์ฅํ๋ ๋ฐฉ์์ ์ฌ์ฉํ๋ค. ์ด๋ Key๋ ์ค์ง์ ์ธ value๋ฅผ ์ฐพ๊ธฐ ์ํ ์ญํ ์ ํ๋ค.
- entry์ ์ ์ฅ ์์๋ฅผ ๊ณ ๋ คํ์ง ์๊ณ ,
- Key๋ ์ค๋ณต์ด ํ์ฉ๋์ง ์๋๋ค.
HashMap ์ Key์ value๋ฅผ ๋ฌถ์ด ํ๋์ entry๋ก ์ ์ฅํ๋ค. ์ด๋ฆ ๊ทธ๋๋ก Hash ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๊ธฐ์ ๋ฐ์ดํฐ์ ๊ฒ์ ์๋๊ฐ ๋น ๋ฅด๋ค.
- ์ญ์๋ Key๋ ์ค๋ณต์ด ๋ถ๊ฐ๋ฅํ๊ณ ,
- value๋ null์ด ๊ฐ๋ฅํ๋ค.
์ค๋ฌด์์๋ ์์ ๊ฐ์ ๊ณต์ ๋๋ ๋ณ์์ ๋ํ ๋์์ฑ ๋ฌธ์ ๋๋ฌธ์
ConcurrentHashMap&AtomicLong๋ฑ์ ์ฌ์ฉํด์ผ ํ๋ค. ๋์์ฑ ์ ์ด์ ๊ด๋ จ๋ ์ฐธ๊ณ : https://devlog-wjdrbs96.tistory.com/269
ํ์ ์ ๋ณด ์ ์ฅ (save)
public Member save(Member member) {
member.setId(++sequence);
store.put(member.getId(), member);
return member;
}
-
๋จผ์ ํด๋น
Member๊ฐ์ฒด์id์sequence + 1ํ ๊ฐ์ setting- 0, 1, 2, ... ์์ผ๋ก ์ ์ฅ
id๋ ์ค๋ณต์ด ํ์ฉ๋์ง ์๋ ๊ณ ์ ํ ๊ฐ์ด์ด์ผ ํ๋ฏ๋ก ์์ ๊ฐ์ด ์ง์ ํ๋ค.
store์ ํด๋นmember์id&member๋ฅผ Key & value ์์ผ๋ก ์ ์ฅ
ํ์ ์ ๋ณด ์กฐํ (Id)
public Optional<Member> findById(Long id) {
return Optional.ofNullable(store.get(id));
}
-
store.get(id)๋ก ์ง์ ํid๋ฅผ ๊ฐ์ง๋member๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ฌ ์ ์๋ค.- ํ์ง๋ง ์ง์ ํ
id๋ฅผ ๊ฐ์ง๋member๊ฐ ์๋ ๊ฒฝ์ฐ, ์ฆNull์ด ๋ฐํ๋ ์ ์๋๋ฐ, ์ด ๋ํ ํด๋ผ์ด์ธํธ์์ ์ฒ๋ฆฌํ ์ ์๋๋ก ํ๊ธฐ ์ํ ์์ ์ด ํ์ํ๋ค. - ๋ฐ๋ผ์,
Optional.ofNullable()๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐํ๋๋ ๊ฐ์ฒด๋ฅผ ๊ฐ์ธ์ค๋ค.
- ํ์ง๋ง ์ง์ ํ
ํ์ ์ ๋ณด ์กฐํ (Name)
public Optional<Member> findByName(String name) {
return store.values().stream()
.filter(member -> member.getName().equals(name))
.findAny();
}
store์์ ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌ๋ฐ์name๊ณผ ๋์ผํname์ ๊ฐ์ง๋member๊ฐ์ฒด๋ฅผ ํ๋๋ผ๋ ์ฐพ์ผ๋ฉด (=findAny()) return ํ๋๋ก ํ๋ค.
ํ์ ์ ๋ณด ์กฐํ (All)
public List<Member> findAll() {
return new ArrayList<>(store.values());
}
- ์ ์ฒด ์ ๋ณด๋ฅผ ์กฐํํ๊ธฐ ์ํด์
store์ ์๋ ๋ชจ๋ ๊ฐ๋ค์ ๊ฐ์ ธ์์ผ ํ๋ค. - ์ด๋,
store.values()๋กstore์ ์๋ ๋ชจ๋Member๋ค์ ๊ฐ์ ธ์จ๋ค. - ๊ทผ๋ฐ, return ํ์ด
List์ด๋ฏ๋กstore์ ์๋ ๊ฐ๋ค์ArrayList์ ๋ด์ ๋ฐํํ๋ค.
๐ ํ์ repository ํ ์คํธ ์ผ์ด์ค ์์ฑ
์์์ ์์ฑํ ํ์ ์ ๋ณด API์ ๊ธฐ๋ฅ์ ํ ์คํธํ๊ธฐ ์ํ Test case๋ฅผ ์์ฑ
- ๊ฐ๋ฐํ ๊ธฐ๋ฅ์ ํ ์คํธํ ๋ main method๋ฅผ ํตํด์ ์คํํ๊ฑฐ๋, ์น ์ ํ๋ฆฌ์ผ์ด์ ์ Controller๋ฅผ ํตํด ํด๋น ๊ธฐ๋ฅ์ ์คํํ๋ค. ์ด๋ฌํ ๋ฐฉ๋ฒ์ ์ค๋นํ๊ณ ์คํํ๋๋ฐ ์ค๋ ๊ฑธ๋ฆฌ๊ณ , ๋ฐ๋ณต ์คํํ๊ธฐ ์ด๋ ต๊ณ ์ฌ๋ฌ ํ ์คํธ๋ฅผ ํ๋ฒ์ ์คํํ๊ธฐ ์ด๋ ต๋ค๋ ๋จ์ ์ด ์๋ค.
- ๋ฐ๋ผ์ ์ด๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด, Java๋ JUnit์ด๋ผ๋ framework๋ก ํ ์คํธ๋ฅผ ์คํํ๋ค.
src/test/java/hello.hellospring/repository/MemoryMemberRepositoryTest ๋ผ๋ ์๋ก์ด class๋ฅผ ์์ฑํ๋ค.
save() Test
package hello.hellospring.repository;
import hello.hellospring.domain.Member;
import org.junit.jupiter.api.Test;
class MemoryMemberRepositoryTest {
MemberRepository repository = new MemoryMemberRepository();
@Test
public void save() {
Member member = new Member();
member.setName("spring");
repository.save(member);
Member result = repository.findById(member.getId()).get();
System.out.println("result = " + (result == member));
}
}
@Test๋ฅผ ํตํด TEST ์ฝ๋์์ ๋ช ์ํ๊ณ , ์๋ก์ดMember๊ฐ์ฒด๋ฅผ ๋ง๋ ๋ค.- ํด๋น ๊ฐ์ฒด์ Name์ setํ๊ณ ,
save()๋ฅผ ์ํํ๋ค. - ์ดํ ๊ธ๋ฐฉ
saveํmember์id์ ๋ณด๋ฅผfindById๋ก ์ฐพ์๋ด์ดresult๋ผ๋Member๊ฐ์ฒด์ ์ ์ฅํ๋ค. - ๋ ๊ฐ์ฒด๊ฐ ๊ฐ๋ค๋ฉด, ๊ทธ๋์ ๋ง์ง๋ง ์ถ๋ ฅ๋ฌธ์
result = true๊ฐ ์ถ๋ ฅ๋๋ค๋ฉด,save๊ธฐ๋ฅ์ ํ ์คํธ๋ ์ ์์ ์ผ๋ก ์๋ฃ๋ ๊ฒ์ด๋ค.
ํ์ง๋ง, ๋งค๋ฒ ๋ ๊ฒฐ๊ณผ๊ฐ ๊ฐ์ ๋น๊ตํ๋ ๊ตฌ๋ฌธ์ผ๋ก๋ ๋ถํธํจ์ ๋๋ ์ ์๋ค.
Assertions.assertEquals(member, result);
-
org.junit.jupiter.api์์ ์ ๊ณตํ๋Assertions๋ก expected, ์ฆ ๊ธฐ๋ํ๋result๊ฐ์ด, actual,member์ ๋์ผํ์ง๋ฅผ ํ์ธํ๋ ์ฝ๋๋ก ํ ์คํธ์ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ ์ ์๋ค.- ํ ์คํธํ๋ ๊ธฐ๋ฅ์ด ์ ์์ ์ผ๋ก ๋์ํ๋ค๋ฉด, ์๋ฌด๋ฐ ์ถ๋ ฅ๋ฌธ ์์ด ์ด๋ก์ ์ฒดํฌ๊ฐ ๋จ๊ณ ,
- ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ, ๊ธฐ๋๊ฐ๊ณผ ์ค์ ๊ฐ์ ๋ํ Error log๊ฐ ์ถ๋ ฅ๋๋ค.
๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก๋,
Assertions.assertThat(member).isEqualTo(result);
-
org.assertj.core.api์์ ์ ๊ณตํ๋Assertions๋ฅผ ์ฌ์ฉํ์ฌ ์์ ๊ฐ์ด ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ด ์๋ค.- ์ด ์ญ์, ์์ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ธ๋ค.
- ์ถ๊ฐ์ ์ผ๋ก,
Assertions์์option + enter(return)โstatic importํ์ฌ ์ดํ์๋Assertions๋ฅผ ๋ช ์ํ์ง ์๊ณ ๋ฐ๋กassertThat๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
findByName() Test
@Test
public void findByName() {
Member member1 = new Member();
member1.setName("spring1");
repository.save(member1);
Member member2 = new Member();
member2.setName("spring2");
repository.save(member2);
Member result = repository.findByName("spring1").get();
assertThat(result).isEqualTo(member1);
}
save()์ ๋ํ Test์ ๋์ผํ๊ฒ ์ํํ๋ค.
Test Class ์์ฒด์ ๋ํ ์คํ์ผ๋ก ์ ์ฒด
@Testmethod๋ค์ ํ ๋ฒ์ ์คํํ ์ ์๋ค.
findAll() Test
@Test
public void findAll() {
Member member1 = new Member();
member1.setName("spring1");
repository.save(member1);
Member member2 = new Member();
member2.setName("spring2");
repository.save(member2);
Member member3 = new Member();
member3.setName("spring3");
repository.save(member3);
List<Member> result = repository.findAll();
assertThat(result.size()).isEqualTo(3);
}
- ๋์ผํ ๋ฐฉ๋ฒ์ผ๋ก Test๋ฅผ ์ํํ๋,
findAll์ด๋ฏ๋ก ๋ฐํํ์ดList์ด๊ธฐ ๋๋ฌธ์result์size()์ ๋ํด ๋น๊ต๋ฅผ ์ํํ๋ค.
์ด์ Class ์ ์ฒด Test๋ฅผ ์คํํ๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํ๊ณ ์๋์ ๊ฐ์ด ๋ช ์ํ ๊ฒ๊ณผ ์คํ ์์๊ฐ ๋ฌ๋ผ์ง ๊ฒ์ ํ์ธํ ์ ์๋ค.
- ์คํ ์์๋ ๋ณด์ฅ๋์ง ์๊ธฐ ๋๋ฌธ์
findAll์์ ์ด๋ฏธmember1&member2๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌfindByName์์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ด๋ค. - ๋ฐ๋ผ์, ๊ฐ
@Test๊ฐ ๋๋ ๋๋ง๋คrepository๋ฅผ ๋น์์ค์ผ ํ๋ค.
Test๋ ์๋ก ์์กด๊ด๊ณ ์์ด ์ค๊ณ๋์ด์ผ ํ๋ค!
MemoryMemberRepository ์ store๋ฅผ ๋น์์ฃผ๋ method๋ฅผ ์ ์ธํ๋ค.
@Override
public void clearStore() {
store.clear();
}
์ดํ, Test์์ ๊ฐ @Test ๊ฐ ๋๋ ์ดํ ์ method๋ฅผ ์ํํ๊ธฐ ์ํด @AfterEach annotation์ ์ด์ฉํ๋ method๋ฅผ ์ ์ธํ๋ค.
@AfterEach
public void afterEach() {
repository.clearStore();
}
- ์ดํ Class ์ ์ฒด๋ฅผ ์คํํ๋ฉด ์๋ฌ ์์ด ์ ์ํ๋๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
ํ ์คํธ ์ฃผ๋ ๊ฐ๋ฐ = TDD ์์ ๊ฐ์ ํ ์คํ ์ฝ๋๋ค์ ๋จผ์ ์ ์ธํ ํ, ๊ฐ๋ฐ์ ์งํํ๋ ๋ฐฉ์
๐ ํ์ ์๋น์ค ๊ฐ๋ฐ
์ค์ ๋น์ฆ๋์ค ๋ก์ง์ ์์ฑํ๋ ๋ถ๋ถ, ์๋น์ค ๋ถ๋ถ์์๋ ๋น์ฆ๋์ค์ ์ธ ์ฉ์ด๋ค๋ก Method๋ฅผ ๊ตฌํํด์ผ ๊ธฐ๋ฅ ์ ์ง ๋ณด์ ์, ์๋ฏธ์ ๋งค์นญ์ด ์ ๋๋ค. (์๋น์ค๋ ๋น์ฆ๋์ค๋ฅผ ์ฒ๋ฆฌํ๋ ์ญํ !)
src/main/java/hello.hellospring/service/MemberService
โ ํ์ ๊ฐ์ ๊ธฐ๋ฅ
private final MemberRepository memberRepository = new MemoryMemberRepository();
// ํ์ ๊ฐ์
public Long join(Member member) {
// ๊ฐ์ ์ด๋ฆ์ธ ์ค๋ณตํ์์ ๋ถ๊ฐ๋ฅํด์ผ ํจ
Optional<Member> result = memberRepository.findByName(member.getName());
result.ifPresent(m -> {
throw new IllegalStateException("์ด๋ฏธ ์กด์ฌํ๋ ํ์์
๋๋ค.");
});
memberRepository.save(member);
return member.getId();
}
- ๋น์ฆ๋์ค ๋ก์ง์์, ์ค๋ณต๋ ์ด๋ฆ์ด ์กด์ฌํ๋ ๊ฒฝ์ฐ ํ์๊ฐ์
์ด ๋ถ๊ฐ๋ฅํด์ผ ํ๊ธฐ์, ์ด๋ฏธ ์์ฑํ
findByNamemethod๋ก ์ด๋ฆ์ ์ฌ๋ถ๋ฅผ ํ์ธํ๋ค. - ์ด๋ฆ์ด ์๋ ๊ฒฝ์ฐ์๋ง
savemethod๋ก ํ์๊ฐ์ ์ด ๊ฐ๋ฅํ๊ฒ ํ๊ณ , ํด๋น ํ์์id๋ฅผ ๋ฐํํ๋ค.
์์ ์ฝ๋๋ฅผ Control + T ๋จ์ถํค๋ฅผ ์ด์ฉํด ๋ฆฌํฉํ ๋ง๊ณผ ๊ด๋ จ๋ ๊ธฐ๋ฅ์ ์ฌ์ฉํ ์ ์๊ณ , Extract Method ํ์ฌ ์๋์ ๊ฐ์ ํํ๋ก ๋ณํํ ์ ์๋ค.
public Long join(Member member) {
// ๊ฐ์ ์ด๋ฆ์ธ ์ค๋ณตํ์์ ๋ถ๊ฐ๋ฅํด์ผ ํจ
ValidateDuplicateMember(member); // ์ด๋ฆ ์ค๋ณต ํ์ ๊ฒ์ฆ
memberRepository.save(member);
return member.getId();
}
private void ValidateDuplicateMember(Member member) {
memberRepository.findByName(member.getName())
.ifPresent(m -> {
throw new IllegalStateException("์ด๋ฏธ ์กด์ฌํ๋ ํ์์
๋๋ค.");
});
}
โ ํ์ ์กฐํ ๊ธฐ๋ฅ
// ์ ์ฒด ํ์ ์กฐํ
public List<Member> findMembers() {
return memberRepository.findAll();
}
// ํน์ ํ์ ์กฐํ
public Optional<Member> findOne(Long memberId) {
return memberRepository.findById(memberId);
}
๐ ํ์ ์๋น์ค ํ ์คํธ
์์์ ๊ตฌํํ ํ์ ์๋น์ค์ ๋ํ ํ
์คํธ๋ฅผ ์ํ, command + shift + T ๋จ์ถํค๋ฅผ ์ด์ฉํด ์์ฝ๊ฒ Test๋ฅผ ์์ฑํ ์ ์๋ค.
@Test
void ํ์๊ฐ์
() {
// given
// when
// then
}
- Test ์ฝ๋๋ ๊ณผ๊ฐํ๊ฒ ํ๊ธ๋ก ๋ฐ๊ฟ๋ ์๊ด์ด ์๋ค. ์ค์ build ๋ ๋, ํ ์คํธ ์ฝ๋๋ ํฌํจ๋์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
-
๊ทธ๋ฆฌ๊ณ Test๋ given, when, then ์ด๋ผ๋ ํฐ ํ๋ก ์ค๊ณํ ์ ์๋ค.
- given: ์ฃผ์ด์ง๋ data
- when: ์ด๋ฅผ ์คํํ์ ๋
- then: ๋์์ผ ํ๋ ๊ฒฐ๊ณผ
@Test
void ํ์๊ฐ์
() {
// given
Member member = new Member();
member.setName("hello");
// when
Long saveId = memberService.join(member);
// then
Member findMember = memberService.findOne(saveId).get();
assertThat(member.getName()).isEqualTo(findMember.getName());
}
thenpart ์์, ์์์joinํ๊ณ ๋ฐํ๋id๋ฅผ ๊ฐ์ง๊ณfindOnemethod๋ฅผ ์คํ- ํ์๊ฐ์
์ด ์ ์ ๋์ํ๋ค๋ฉด,
member๊ฐ์ฒด์Name๊ณผfindOne์ ๋ฐํ ๊ฐ์ฒด์ธfindMember์Name์ด ๋์ผํ ๊ฒ์ด๋ค.
์์ Test code๋ ์ฌ์ค์ ๋ฐ์ชฝ์ง๋ฆฌ Test code ์ด๋ค.
- ์๋ํ๋ฉด, Test๋ ์์ธ์ ๋ํด์๋ ์ํ๋์ด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค. (๊ทธ๋ฆฌ๊ณ
service์ ์ค๋ณตํ์์ฒดํฌ method๋ ์๊ธฐ ๋๋ฌธ์ ํด๋น Test๋ ํ์ํ๋ค.)
@Test
public void ์ค๋ณต_ํ์_์์ธ() {
// given
Member member1 = new Member();
member1.setName("spring");
Member member2 = new Member();
member2.setName("spring");
// when
memberService.join(member1);
try {
memberService.join(member2);
fail();
} catch (IllegalStateException e) {
assertThat(e.getMessage()).isEqualTo("์ด๋ฏธ ์กด์ฌํ๋ ํ์์
๋๋ค.");
}
// then
}
- ๊ฐ์ ์ด๋ฆ์ ๊ฐ์ง ๋ ํ์์ ์์ฑํ๊ณ ๊ฐ๊ฐ
join์ ์ํํ๋ ค ํ๋ค. try - catch๊ตฌ๋ฌธ์ผ๋ก, ๋ฐ์ํ Exception์ message๋ฅผ ๋น๊ตํ์ฌ Test๋ฅผ ์ํํ๋ค.
ํ์ง๋ง, ๋ค๋ฅธ ๋ฌธ๋ฒ์ผ๋ก ๋ ๊น๋ํ๊ฒ Test๋ฅผ ์ํํ ์ ์๋ค.
assertThrows(IllegalStateException.class, () -> memberService.join(member2));
assertThrows๋ฅผ ์ด์ฉํด() -> memberService.join(member2)๊ฐ ์ํ๋ ๋,IllegalStateException์์ธ๊ฐ ๋ฐ์ํด์ผ ํจ์ ๋ช ์ํ๋ค.
IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
assertThat(e.getMessage()).isEqualTo("์ด๋ฏธ ์กด์ฌํ๋ ํ์์
๋๋ค.");
asserThrows๋ ๋ฐํ์ด ๊ฐ๋ฅ(command + option + V๋ก ๋ฐํ๋ฐ์ ๊ฐ์ฒด ์ ์ธ)ํ๊ธฐ์, Exception message์ ๋ํ ๊ฒ์ฆ๋ ๊ฐ๋ฅํ๋ค.
์ด์ ์ Test์ ๋์ผํ๊ฒ, ์คํ ์์๊ฐ ๋ณด์ฅ๋์ง ์์ ์๋ฌ๊ฐ ๋ฐ์ํ ์ ์๋ค.
์ด๋ฅผ ์ํด ์ด์ ์๋ @AfterEach ๋ก MemoryMemberRepository ์์ ์์ฑํ clearStore method๋ฅผ ์ฌ์ฉํ์๋ค.
MemberService memberService = new MemberService();
MemoryMemberRepository memberRepository = new MemoryMemberRepository();
@AfterEach
public void afterEach() {
memberRepository.clearStore();
}
MemberService ์์๋ MemoryMemberRepository ๊ฐ์ฒด๋ฅผ ์ ์ธํ์ฌ ์ฌ์ฉํ๋๋ฐ, ์ ์ฝ๋์์๋ ํ ๋ฒ ๋ ํด๋น ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ์ฌ์ฉํ๊ณ ์๋ค.
์ฆ, MemberService ์์ ์ฌ์ฉํ๋ MemoryMemberRepository ์ MemberServiceTest ์์ ์ฌ์ฉํ๋ MemoryMemberRepository ๋ ์๋ก ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ์ฌ์ฉํ๊ธฐ์, MemoryMemberRepository ์์ Map<> store ๊ฐ Class์ ์ข
์์ ์ธ static ์ด ์๋๋ผ๋ฉด ๊ฐ์ฒด ์์ฑ๋ง๋ค ๋ค๋ฅธ DB๊ฐ ๋์ด๋ฒ๋ ค ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๊ฒ ๋๋ค.
MemberService.java
private final MemberRepository memberRepository = new MemoryMemberRepository();
โ
private final MemberRepository memberRepository;
public MemberService(MemberRepository memberRepository) {
this.memberRepository = memberRepository;
}
- Contructor๋ฅผ ์์ฑํ์ฌ ์ง์
new๋ก ์์ฑํ์ง ์๊ณ , ์ธ๋ถ์์ ์ ๋ฌํด์ฃผ๋๋ก ๋ณ๊ฒฝ
MemberServiceTest.java
MemberService memberService;
MemoryMemberRepository memberRepository;
@BeforeEach
public void beforeEach() {
memberRepository = new MemoryMemberRepository();
memberService = new MemberService(memberRepository);
}
BeforeEachannotation์ผ๋ก, ๊ฐ Test Method๊ฐ ์ํ๋๊ธฐ ์ ์MemoryMemberRepsotiory๋ฅผ ์์ฑํ๊ณ ์ด๋ฅผMemberService์ ์ ๋ฌํ์ฌ ์ฌ์ฉํจ์ผ๋ก์จ, ๊ฐ์ Repository๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ํ๋ค.
์ด๋ฅผ Dependency Injection (์์กด์ฑ ์ฃผ์ ) ์ด๋ผ๊ณ ํ๋ค.
๐ ์ค์ํ ๊ฐ๋
Optional, Test, Dependency Injection